home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1996 #15 / Monster Media Number 15 (Monster Media)(July 1996).ISO / bbs_util / bsrc_260.zip / SRC.ZIP / LANGLOAD.C < prev    next >
C/C++ Source or Header  |  1996-02-20  |  8KB  |  248 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      ------------         Bit-Bucket Software, Co.                       */
  5. /*      \ 10001101 /         Writers and Distributors of                    */
  6. /*       \ 011110 /          Freely Available<tm> Software.                 */
  7. /*        \ 1011 /                                                          */
  8. /*         ------                                                           */
  9. /*                                                                          */
  10. /*              (C) Copyright 1987-96, Bit Bucket Software Co.              */
  11. /*                                                                          */
  12. /*               This module was written by Vince Perriello                 */
  13. /*                                                                          */
  14. /*                    BinkleyTerm Language File Loader                      */
  15. /*                                                                          */
  16. /*                                                                          */
  17. /*    For complete  details  of the licensing restrictions, please refer    */
  18. /*    to the License  agreement,  which  is published in its entirety in    */
  19. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.260.    */
  20. /*                                                                          */
  21. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  22. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  23. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  24. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  25. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  26. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  27. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  28. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  29. /*                                                                          */
  30. /*                                                                          */
  31. /* You can contact Bit Bucket Software Co. at any one of the following      */
  32. /* addresses:                                                               */
  33. /*                                                                          */
  34. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:343/491             */
  35. /* P.O. Box 460398                AlterNet 7:42/1491                        */
  36. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  37. /*                                Internet f491.n343.z1.fidonet.org         */
  38. /*                                                                          */
  39. /* Please feel free to contact us at any time to share your comments about  */
  40. /* our software and/or licensing policies.                                  */
  41. /*                                                                          */
  42. /*--------------------------------------------------------------------------*/
  43.  
  44. /* Include this file before any other includes or defines! */
  45.  
  46. #include "includes.h"
  47.  
  48. #define LANGFILE        ( PRDCT_PRFX ".LNG" )
  49.  
  50. /*
  51.  * Read the compiled BinkleyTerm Language file.
  52.  *
  53.  */
  54.  
  55. int 
  56. load_language (void)
  57. {
  58.     int pointer_size;
  59.     char *memory;
  60.     unsigned int memory_size;
  61.     char *malloc_target;
  62.     char *envptr;
  63.     char LANGpath[128];
  64.     int error;
  65.     int i;
  66.     int iReadT;
  67.     struct stat stbuf;
  68.     FILE *fpt;                                /* stream pointer           */
  69.     char *Ptr;
  70.  
  71.     envptr = getenv (PRDCT_PRFX);            /* get path from environment*/
  72.     if ((envptr != NULL)                    /* If there was one, and    */
  73.         && (!dexists (LANGFILE)))            /* No local language file,  */
  74.     {
  75.         (void) strcpy (LANGpath, envptr);    /* use BINKLEY as our path  */
  76.         (void) add_backslash (LANGpath);
  77.     }
  78.     else
  79.         LANGpath[0] = '\0';
  80.  
  81.     (void) strcat (LANGpath, LANGFILE);
  82.  
  83.    /*
  84.     * Get some info about the file
  85.     */
  86.  
  87.     error = stat (LANGpath, &stbuf);
  88.     if (error != 0)
  89.     {
  90.         (void) fprintf (stderr, "Cannot get information on file %s\n", LANGpath);
  91.         exit (250);
  92.     }
  93.  
  94.    /*
  95.     * Allocate space for the raw character array and for the
  96.     * pointer and fixup arrays
  97.     *
  98.     */
  99.  
  100.     memory_size = (unsigned int) stbuf.st_size;
  101.     Ptr = malloc_target = calloc (1, memory_size);
  102.     if (malloc_target == NULL)
  103.     {
  104.         (void) fprintf (stderr, "Unable to allocate string memory\n");
  105.         exit (250);
  106.     }
  107.  
  108.    /*
  109.     * Open the input file
  110.     *
  111.     */
  112.  
  113.     fpt = share_fopen (LANGpath, read_binary, DENY_WRITE);
  114.     if (fpt == NULL)                        /* Were we successful?       */
  115.     {
  116.         (void) fprintf (stderr, "Can not open input file %s\n", LANGpath);
  117.         exit (250);
  118.     }
  119.  
  120.    /*
  121.     * Read the entire file into memory now.
  122.     *
  123.     */
  124.     iReadT = fread (malloc_target, 1, memory_size, fpt);
  125.     if ((unsigned) iReadT != memory_size)
  126.     {
  127.         (void) fprintf (stderr, "Could not read language data from file %s\n", LANGpath);
  128.         (void) fclose (fpt);
  129.         exit (250);
  130.     }
  131.  
  132.    /*
  133.     * Close the file.
  134.     *
  135.     */
  136.  
  137.     error = fclose (fpt);
  138.     if (error != 0)
  139.     {
  140.         (void) fprintf (stderr, "Unable to close language file %s\n", LANGpath);
  141.         exit (250);
  142.     }
  143.  
  144.    /*
  145.     * Do fixups on the string pointer array as follows:
  146.     *
  147.     * 1. Get element count from input
  148.     * 2. Start of the string memory immediately follows the strings
  149.     * 3. Apply arithmetic correction to entire array.
  150.     *
  151.     */
  152.  
  153.     LangHdr = (struct _lang_hdr *) malloc_target;
  154.     msgtxt = (char **) (malloc_target + sizeof (struct _lang_hdr));
  155.  
  156.     pointer_size = LangHdr->ElemCnt;    /* Count of elements w/o NULL*/
  157.     if (pointer_size != X_TOTAL_MSGS)
  158.     {
  159.         (void) fprintf (stderr, "Count of %d from file does not match %d required\n",
  160.             pointer_size, X_TOTAL_MSGS);
  161.         exit (250);
  162.     }
  163.     memory = (char *) &msgtxt[pointer_size];    /* Text starts after pointers*/
  164.     for (i = 1; i < pointer_size; i++)
  165.     {
  166.         msgtxt[i] = memory + (int) (msgtxt[i] - msgtxt[0]);
  167.     }
  168.     msgtxt[0] = memory;
  169.  
  170.    /*
  171.     * Process the Terminal Mode Keymap.
  172.     *
  173.     * First comes the integer count.
  174.     * Following that is the array of keymaps.
  175.     *
  176.     */
  177.  
  178.     Ptr = (char *) LangHdr
  179.         + sizeof (struct _lang_hdr)
  180.     + (sizeof (char *) * (LangHdr->ElemCnt))
  181.     + LangHdr->PoolSize;
  182.  
  183.     TrmnlKeyFncHdr.KeyFncCnt = *(short *) Ptr;
  184.     Ptr += sizeof (short);
  185.  
  186.     TrmnlKeyFncHdr.KeyFncTbl = (struct _key_fnc *) Ptr;
  187.  
  188.     Ptr += sizeof (struct _key_fnc) * TrmnlKeyFncHdr.KeyFncCnt;
  189.  
  190.    /*
  191.     * Process the Unattended Mode Keymap.
  192.     *
  193.     * First comes the integer count.
  194.     * Following that is the array of keymaps.
  195.     *
  196.     */
  197.  
  198.     UnattendedKeyFncHdr.KeyFncCnt = *(short *) Ptr;
  199.     Ptr += sizeof (short);
  200.  
  201.     UnattendedKeyFncHdr.KeyFncTbl = (struct _key_fnc *) Ptr;
  202.  
  203.     Ptr += sizeof (struct _key_fnc) * UnattendedKeyFncHdr.KeyFncCnt;
  204.  
  205.    /*
  206.     * Process the product code table.
  207.     *
  208.     * This looks a lot like the language stuff above.
  209.     *
  210.     * The first thing we have here is the header (which contains a count).
  211.     * Following that, the pointer array.
  212.     * Finally, the strings themselves.
  213.     *
  214.     * Get all of that sorted out, do fixups on the string array, and
  215.     * everything should be ducky.
  216.     */
  217.  
  218.     PrdctHdr = (struct _lang_hdr *) Ptr;
  219.     PrdctTbl = (char **) (Ptr + sizeof (struct _lang_hdr));
  220.  
  221.     memory = (char *) PrdctTbl
  222.         + (sizeof (char *) * PrdctHdr->ElemCnt);
  223.  
  224.     memory += strlen (memory) + 1;
  225.  
  226.     for (i = 1; i < PrdctHdr->ElemCnt; i++)
  227.     {
  228.         PrdctTbl[i] = memory + (int) (PrdctTbl[i] - PrdctTbl[0]);
  229.     }
  230.     PrdctTbl[0] = memory;
  231.  
  232.     Ptr += sizeof (struct _lang_hdr)
  233.     + (sizeof (char *) * (PrdctHdr->ElemCnt))
  234.     + PrdctHdr->PoolSize;
  235.  
  236.     /*
  237.     * Finally set up the ANSI output mapping table.
  238.     *
  239.     * This one is easy. Just point at it.
  240.     */
  241.  
  242.     AnsiHdr = (struct _lang_hdr *) Ptr;
  243.     AnsiTbl = (char *) (Ptr + sizeof (struct _lang_hdr));
  244.  
  245.     return (1);
  246. }
  247.  
  248.